home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 5 / Apprentice-Release5.iso / Source Code / SDKs / Word Services SDK 1.0.6 / Writeswell Jr 1.2.1 Sources ƒ / Writeswell Jr. Source / ServiceMgr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-09-11  |  10.9 KB  |  484 lines  |  [TEXT/KAHL]
  1. /* ServiceMgr.c
  2.  * Handle the Services menu in Writeswell, Jr.
  3.  * ©1992 Working Software, Inc.
  4.  * This source code is copyrighted.  Permission is granted to use the Word Services
  5.  * portion of the Writeswell Jr. source code in your own programs, but you 
  6.  * may not distribute the Writeswell Jr. word-processor code as a 
  7.  * commercial product.  If you modify the code, please do not call it 
  8.  * Writeswell Jr. (or Writeswell.)  This will ensure that people understand the 
  9.  * program and don’t have to deal with a number of different versions with 
  10.  * who-knows-what going on in the code.
  11.  * 
  12.  * Writeswell Jr. and Writeswell are trademarks of Working Software, Inc.
  13.  * 19 Apr 92 Mike Crawford
  14.  */
  15.  
  16. #include <Aliases.h>
  17. #include <EPPC.h>
  18. #include <AppleEvents.h>
  19. #include <AEObjects.h>
  20. #include <AEPackObject.h>
  21. #include "AERegistry.h"
  22. #include "WordServices.h"
  23. #include "TestBed.h"
  24. #include "TBConstants.h"
  25. #include "AppEvents.h"
  26. #include "AEObj.h"
  27. #include "Gripe.h"
  28. #include "Prefs.h"
  29. #include "DoChecking.h"
  30. #include "ObText.h"
  31. #include "InitMenu.h"
  32. #include "ServiceMgr.h"
  33. #include "TBGlobals.h"
  34.  
  35. OSErr GetNewBatchService( void )
  36. {
  37.     AEAddressDesc    spellerAddr;
  38.     AEDesc            stringDesc;
  39.     AEDesc            aliasDesc;
  40.     AEDesc            iconDesc;
  41.     OSErr            err;
  42.     
  43.     if ( CountServices() >= kMaxServices ){
  44.         RealGripe( "\pNo more services may be added" );
  45.         return noErr;
  46.     }
  47.  
  48.     /* Look for a currently running speller */
  49.  
  50.     err = GetSpellerAddress( &spellerAddr );
  51.     if ( err ){
  52.         return ( err == userCanceledErr ? noErr : err );
  53.     }
  54.  
  55.     /*****
  56.      * Request the speller's batch menu string
  57.      *****/
  58.     
  59.     err = GetAppProperty( &spellerAddr, pBatchMenuString, typePString, &stringDesc );
  60.     if ( err ){
  61.         Gripe( "\pGetAppProperty failed to get menu string" );
  62.         return err;
  63.     }
  64.     
  65.     /*DebugStr( *(stringDesc.dataHandle) );*/    /* Uncomment this to look at string */
  66.     
  67.     
  68.     /*****
  69.      * Request the speller's location alias
  70.      *****/
  71.  
  72.     err = GetAppProperty( &spellerAddr, pLocation, typeAlias, &aliasDesc );
  73.     if ( err ){
  74.         Gripe( "\pGetAppProperty failed to get location alias" );
  75.         return err;
  76.     }
  77.     
  78.     /*
  79.         pMenuIcon
  80.         Description:    The value of this property is a small icon that may be
  81.                         placed in the menu  along with the interactive or batch
  82.                         menu strings.  It should be identical to the small icon
  83.                         that the speller shows in the Finder.  Word processors that
  84.                         take advantage of this can use it to make the different menu
  85.                         items more distinguishable (a user might have two different
  86.                         spelling checkers).
  87.         Object Class ID:    typePixelMap
  88.      */
  89.  
  90.     iconDesc.dataHandle = (Handle)NULL;
  91.     iconDesc.descriptorType = typeNull;
  92.  
  93.     err = GetAppProperty( &spellerAddr, pMenuIcon, typeSmallIcon, &iconDesc );
  94.     
  95.     /* It is permissible for the icon not to be present.  We just won't display one.
  96.      */
  97.  
  98.     if ( err && err != errAENoSuchObject ){
  99.         Gripe( "\pGetAppProperty failed to get speller menu icon" );
  100.         return err;
  101.     }
  102.     
  103.     /* Save the information in the preferences file */
  104.     
  105.     err = SaveServiceInfo( kBatchService, stringDesc, aliasDesc, iconDesc );
  106.     if ( err ){
  107.         Gripe( "\pCould not save service info" );
  108.         return err;
  109.     }
  110.     
  111.     RebuildServiceMenu();
  112.     
  113.     err = AEDisposeDesc( &stringDesc );
  114.     if ( err ){
  115.         Gripe( "\pAEDisposeDesc failed" );
  116.         return err;
  117.     }
  118.  
  119.     err = AEDisposeDesc( &aliasDesc );
  120.     if ( err ){
  121.         Gripe( "\pAEDisposeDesc failed" );
  122.         return err;
  123.     }
  124.  
  125.     err = AEDisposeDesc( &iconDesc );
  126.     if ( err ){
  127.         Gripe( "\pAEDisposeDesc failed" );
  128.         return err;
  129.     }
  130.  
  131.     err = AEDisposeDesc( &spellerAddr );
  132.     if ( err ){
  133.         Gripe( "\pAEDisposeDesc failed" );
  134.         return err;
  135.     }
  136.     spellerAddr.descriptorType = typeNull;
  137.     spellerAddr.dataHandle = (Handle)NULL;
  138.  
  139.     return noErr;
  140. }
  141.  
  142. OSErr GetAppProperty( AEAddressDesc *spellerAddrPtr,
  143.                         DescType propCode,
  144.                         DescType desiredType,
  145.                         AEDesc *resultPtr )
  146. {
  147.     AEDesc            errDesc;
  148.     AppleEvent        getDataEvent;
  149.     AppleEvent        replyEvent;
  150.     AEDesc            nullDesc;
  151.     AEDesc            propSpec;
  152.     AEDesc            propDesc;
  153.     OSErr            err;
  154.  
  155.     /* Create the descriptor for the container (the application, or null) */
  156.  
  157.     err = AECreateDesc( typeNull, (Ptr)NULL, (Size)0, &nullDesc );
  158.     if ( err )
  159.         return err;
  160.     
  161.     /* Create the key data, which gives the code for the desired property */
  162.  
  163.     err = AECreateDesc( typeType, (Ptr)&propCode, sizeof( propCode ), &propDesc );
  164.     if ( err )
  165.         return err;
  166.  
  167.     /* Create the Object Specifier for the menu string property */
  168.     
  169.     err = CreateObjSpecifier( typeProperty,
  170.                                 &nullDesc,
  171.                                 formPropertyID,
  172.                                 &propDesc,
  173.                                 true,                    /* Dispose of input descriptors */
  174.                                 &propSpec );
  175.     if ( err )
  176.         return err;
  177.  
  178.     /* Create the event to send to the speller */
  179.     
  180.     err = AECreateAppleEvent( kAECoreSuite,
  181.                                 kAEGetData,
  182.                                 spellerAddrPtr,
  183.                                 kAutoGenerateReturnID,
  184.                                 kAnyTransactionID,
  185.                                 &getDataEvent );
  186.     
  187.     if ( err ){
  188.         Gripe( "\pcreate getd event failed" );
  189.         return err;
  190.     }
  191.     
  192.     /* Insert the object specifier as the direct object of the batch event */
  193.  
  194.     err = AEPutParamDesc( &getDataEvent,
  195.                             keyDirectObject,
  196.                             &propSpec );
  197.     if ( err ){
  198.         Gripe( "\pAEPutParamDesc failed to put direct object on Get Data event" );
  199.         return err;
  200.     }
  201.     err = AEDisposeDesc( &propSpec );
  202.     if ( err ){
  203.         Gripe( "\pAEDisposeDesc failed" );
  204.         return err;
  205.     }
  206.  
  207.     /* Send the event.  We await the reply, so that if there is a failure of some
  208.      * sort in the initial connection, we can alert the user right away.  The timeout
  209.      * value to use here should be as long as one would care to have a user wait for
  210.      * the completion of a menu command.  Since we expect that the speller is on a local
  211.      * machine in this case, and should be able to respond immediately, we just give
  212.      * a few seconds for the timeout.
  213.      *
  214.      * We should assign an idle proc to spin the cursor.  Even better would be a progress
  215.      * dialog that says "Contacting speller" or some such, with an animated display that
  216.      * shows the time elapsed relative to the total timeout, so the user will know how
  217.      * long she may have to wait
  218.      */
  219.  
  220. #define kFewSeconds 300
  221.     
  222.     err = AESend( &getDataEvent,
  223.                     &replyEvent,
  224.                     kAEWaitReply + kAENeverInteract,
  225.                     kAENormalPriority,
  226.                     kFewSeconds,
  227.                     (AEIdleUPP)NULL,
  228.                     (AEFilterUPP)NULL );
  229.     
  230.     if ( err ){
  231.         Gripe( "\psend getd event failed" );
  232.         return err;
  233.     }
  234.     err = AEDisposeDesc( &getDataEvent );
  235.     if ( err ){
  236.         Gripe( "\pAEDisposeDesc failed" );
  237.         return err;
  238.     }
  239.  
  240.     /* At this point we have received the client's reply event.  Check for an error
  241.      * result.
  242.      */
  243.     
  244.     err = AEGetParamDesc( &replyEvent,
  245.                             keyErrorNumber,
  246.                             typeShortInteger,
  247.                             &errDesc );
  248.  
  249.     if ( err == errAEDescNotFound ){
  250.         /* There is no error value - get the data from the reply event.
  251.          * This will call our coercion routine to convert the text to a Pascal string -
  252.          * the data is actually either typeIntlText or typeChar.
  253.          */
  254.  
  255.         err = AEGetParamDesc( &replyEvent,
  256.                                 keyDirectObject,
  257.                                 desiredType,
  258.                                 resultPtr );
  259.         if ( err ){
  260.             Gripe( "\pCannot get reply value" );
  261.             return err;
  262.         }        
  263.     
  264.         /* MDC 1.1.1 */
  265.  
  266.         err = AEDisposeDesc( &replyEvent );
  267.         if ( err ){
  268.             Gripe( "\pAEDisposeDesc failed" );
  269.             return err;
  270.         }
  271.  
  272.     } else {
  273.         err = AEDisposeDesc( &replyEvent );
  274.         if ( err ){
  275.             Gripe( "\pAEDisposeDesc failed" );
  276.             return err;
  277.         }
  278.     
  279.         err = **(short**)(errDesc.dataHandle);
  280.         /* err = */ AEDisposeDesc( &propSpec );
  281.     
  282.         if ( err ){
  283.             if ( err == errAENoSuchObject )
  284.                 return err;                        /* This is an OK error */
  285.             else{
  286.                 Gripe( "\pError result returned from speller" );
  287.                 return err;
  288.             }
  289.         }
  290.     }
  291.  
  292.     return noErr;
  293. }
  294. void RebuildServiceMenu( void )
  295. {
  296.     MenuHandle        servMenu;
  297.     short            numItems;
  298.     short            i;
  299.     
  300.     servMenu = GetServiceMenu();
  301.     if ( !servMenu ){
  302.         Gripe( "\pCannot get service menu handle" );
  303.         return;
  304.     }
  305.     
  306.     numItems = CountMItems( servMenu );
  307.     
  308.     for ( i = numItems; i > kSMDash; i-- ){
  309.         DelMenuItem( servMenu, i );
  310.     }
  311.     
  312.     BuildServiceMenu();
  313.     
  314.     return;
  315. }
  316.  
  317. OSErr GetSpellerAddress( AEAddressDesc    *spellerAddrPtr )
  318. {
  319.     PortInfoRec portInfo;
  320.     TargetID    targetID;
  321.     OSErr        err;
  322.  
  323.     err = GetTargetAddress( (StringPtr)"\pChoose a Word Services Server",
  324.                             (StringPtr)"\pApple Event Aware Programs",
  325.                             &portInfo,
  326.                             spellerAddrPtr,
  327.                             (StringPtr)"\pWORDSERVICES",
  328.                             &targetID );
  329.     return err;
  330. }
  331.  
  332. short CountServices( void )
  333. {
  334.     WWJrPrefsHdl    prefHdl;
  335.     short            i;
  336.     short            count;
  337.     
  338.     prefHdl = GetPrefHandle();
  339.     if ( !prefHdl ){
  340.         Gripe( "\pCannot get preferences handle" );
  341.         return kMaxServices;
  342.     }
  343.  
  344.     count = 0;
  345.     
  346.     for ( i = 0; i < kMaxServices; i++ ){
  347.         if ( (*prefHdl)->serviceType[ i ] != kNoService )
  348.             count++;
  349.     }
  350.     
  351.     return count;
  352. }
  353.  
  354. short GetServiceSlot( void )
  355. {
  356.     WWJrPrefsHdl    prefHdl;
  357.     short            i;
  358.     
  359.     prefHdl = GetPrefHandle();
  360.     if ( !prefHdl ){
  361.         Gripe( "\pCannot get preferences handle" );
  362.         return kMaxServices;
  363.     }
  364.     
  365.     for ( i = 0; i < kMaxServices; i++ ){
  366.         if ( (*prefHdl)->serviceType[ i ] == kNoService )
  367.             return i;
  368.     }
  369.     
  370.     return kMaxServices;            /* No Free slots */
  371. }
  372.  
  373. OSErr SaveServiceInfo( ServiceType serviceType,
  374.                         AEDesc menuDesc,
  375.                         AEDesc aliasDesc,
  376.                         AEDesc iconDesc )
  377. {
  378.     short            slot;
  379.     WWJrPrefsHdl    prefHdl;
  380.     short            resID;
  381.     short            iconResID;
  382.     Handle            resHandle;
  383.     short            curFile;
  384.     OSErr            err;
  385.  
  386.     slot = GetServiceSlot();
  387.     
  388.     if ( slot == kMaxServices ){
  389.         Gripe( "\pOut of slots for new services" );
  390.         return ioErr;                                /* Not sure what a good error would be */
  391.     }
  392.     
  393.     prefHdl = GetPrefHandle();
  394.     if ( !prefHdl ){
  395.         Gripe( "\pCannot get preferences handle" );
  396.         return resNotFound;
  397.     }
  398.  
  399.     resID = kServiceBaseID + slot;
  400.     
  401.     curFile = CurResFile();
  402.     UseResFile( gPrefFileRefNum );
  403.     
  404.     /* Make sure there's no old resources around... there shouldn't be */
  405.  
  406.     resHandle = GetResource( 'STR ', resID );
  407.     if ( resHandle )
  408.         RmveResource( resHandle );
  409.  
  410.     resHandle = GetResource( rAliasType, resID );
  411.     if ( resHandle )
  412.         RmveResource( resHandle );
  413.     
  414.     /* Copy the string into the resource file */
  415.     
  416.     resHandle = menuDesc.dataHandle;
  417.     
  418.     err = HandToHand( &resHandle );
  419.     if ( err ){
  420.         UseResFile( curFile );
  421.         return err;
  422.     }
  423.     
  424.     AddResource( resHandle, 'STR ', resID, "\p" );
  425.     err = ResError();
  426.     if ( err ){
  427.         DisposHandle( resHandle );
  428.         UseResFile( curFile );
  429.         return err;
  430.     }
  431.     WriteResource( resHandle );
  432.     
  433.     /* Copy the alias record into the resource file */
  434.     
  435.     resHandle = aliasDesc.dataHandle;
  436.     
  437.     err = HandToHand( &resHandle );
  438.     if ( err ){
  439.         UseResFile( curFile );
  440.         return err;
  441.     }
  442.     
  443.     AddResource( resHandle, rAliasType, resID, "\p" );    /* rAliasType is 'alis' */
  444.     err = ResError();
  445.     if ( err ){
  446.         DisposHandle( resHandle );
  447.         UseResFile( curFile );
  448.         return err;
  449.     }
  450.     WriteResource( resHandle );
  451.  
  452.     /* Copy the menu icon into the resource file */
  453.     
  454.     resHandle = iconDesc.dataHandle;
  455.  
  456.     if ( iconDesc.descriptorType != typeNull && resHandle != (Handle)NULL ){
  457.     
  458.         err = HandToHand( &resHandle );
  459.         if ( err ){
  460.             UseResFile( curFile );
  461.             return err;
  462.         }
  463.         
  464.         iconResID = kMenuIconBaseID + slot;
  465.         
  466.         AddResource( resHandle, 'SICN', iconResID, "\p" );
  467.         err = ResError();
  468.         if ( err ){
  469.             DisposHandle( resHandle );
  470.             UseResFile( curFile );
  471.             return err;
  472.         }
  473.         WriteResource( resHandle );
  474.     }
  475.  
  476.     (*prefHdl)->serviceType[ slot ] = serviceType;
  477.     
  478.     ChangedResource( (Handle) prefHdl );
  479.     WriteResource( (Handle) prefHdl );
  480.     
  481.     UseResFile( curFile );
  482.  
  483.     return noErr;
  484. }